package com.english.controller;

import com.english.entity.User;
import com.english.service.UserService;
import com.english.utils.R;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

/**
 * 用户控制器
 * 处理用户登录、注册、信息管理等功能
 *
 * @author sqh
 * @since 2025-01-15
 */
@RestController
    @RequestMapping("/api/user")
public class UserController {

    @Autowired
    private UserService userService;

    /**
     * 微信登录
     * @param loginData 包含code和用户信息的登录数据
     * @return 登录结果
     */
    @PostMapping("/wechat-login")
    public R<Map<String, Object>> wechatLogin(@RequestBody Map<String, Object> loginData) {
        try {
            String code = (String) loginData.get("code");
            String name = (String) loginData.get("name");
            String phone = (String) loginData.get("phone");
            Integer role = (Integer) loginData.get("role");

            if (code == null || code.isEmpty()) {
                return R.error("微信授权码不能为空");
            }

            // 调用服务层处理微信登录
            Map<String, Object> result = userService.wechatLogin(code, name, phone, role);

            if ((Boolean) result.get("success")) {
                return R.success(result);
            } else {
                return R.error((String) result.get("message"));
            }

        } catch (Exception e) {
            e.printStackTrace();
            return R.error("登录失败：" + e.getMessage());
        }
    }

    /**
     * 检查用户是否存在（仅检查，不创建用户）
     * @param loginData 包含code的登录数据
     * @return 检查结果
     */
    @PostMapping("/check-user")
    public R<Map<String, Object>> checkUser(@RequestBody Map<String, Object> loginData) {
        try {
            String code = (String) loginData.get("code");

            if (code == null || code.isEmpty()) {
                return R.error("微信授权码不能为空");
            }

            // 调用服务层检查用户是否存在
            Map<String, Object> result = userService.checkUserExists(code);

            if ((Boolean) result.get("success")) {
                return R.success(result);
            } else {
                return R.error((String) result.get("message"));
            }

        } catch (Exception e) {
            e.printStackTrace();
            return R.error("检查用户失败：" + e.getMessage());
        }
    }

    /**
     * 获取当前用户信息（根据token）
     * @return 当前用户信息
     */
    @GetMapping("/info")
    public R<User> getCurrentUserInfo(@RequestHeader("Authorization") String token) {
        try {
            // 从token中提取wechatId（这里简化处理，实际应该解析JWT token）
            String wechatId = extractWechatIdFromToken(token);
            if (wechatId == null) {
                return R.error("无效的token");
            }

            User user = userService.getUserByWechatId(wechatId);
            if (user == null) {
                return R.error("用户不存在");
            }
            return R.success(user);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("获取用户信息失败：" + e.getMessage());
        }
    }

    /**
     * 获取用户信息
     * @param wechatId 微信ID
     * @return 用户信息
     */
    @GetMapping("/info/{wechatId}")
    public R<User> getUserInfo(@PathVariable String wechatId) {
        try {
            User user = userService.getUserByWechatId(wechatId);
            System.err.println(wechatId);
            if (user == null) {
                return R.error("用户不存在");
            }
            return R.success(user);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("获取用户信息失败：" + e.getMessage());
        }
    }

    /**
     * 获取用户统计信息
     * @param token 认证token
     * @return 用户统计信息
     */
    @GetMapping("/stats")
    public R<Map<String, Object>> getUserStats(@RequestHeader("Authorization") String token) {
        try {
            String wechatId = extractWechatIdFromToken(token);
            if (wechatId == null) {
                return R.error("无效的token");
            }

            User user = userService.getUserByWechatId(wechatId);
            if (user == null) {
                return R.error("用户不存在");
            }

            // 获取用户统计信息
            Map<String, Object> stats = userService.getUserStats(user.getId());
            return R.success(stats);
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("获取统计信息失败：" + e.getMessage());
        }
    }

    /**
     * 更新用户信息
     * @param user 用户信息
     * @return 更新结果
     */
    @PutMapping("/update")
    public R<String> updateUserInfo(@RequestBody User user) {
        try {
            boolean success = userService.updateUser(user);
            if (success) {
                return R.success("更新成功");
            } else {
                return R.error("更新失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            return R.error("更新失败：" + e.getMessage());
        }
    }

    /**
     * 从token中提取wechatId（简化实现）
     * @param token 认证token
     * @return wechatId
     */
    private String extractWechatIdFromToken(String token) {
        // 当前实现：token格式为 "token_wechatId_timestamp"
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
        }

        if (token != null && token.startsWith("token_")) {
            String[] parts = token.split("_");
            if (parts.length >= 2) {
                return parts[1]; // 返回wechatId部分
            }
        }

        return null;
    }
}
